OOP 特性

封装、继承和多态：Java 的三大面向对象编程（OOP）特性

Java 是一种面向对象编程语言，面向对象编程（OOP）通过将数据和方法封装在对象中，旨在提高程序的可维护性、可扩展性和复用性。OOP 主要包括以下三大核心特性：封装、继承、多态。

1. 封装（Encapsulation）

封装是将对象的状态（字段）和行为（方法）封装在一起，防止外部直接访问对象的内部数据，只允许通过公共的接口（getter 和 setter 方法）来访问和修改对象的状态。封装的关键在于数据隐藏，即通过访问控制修饰符控制外部对对象的访问权限。

封装的好处：

保护对象的内部状态：通过访问控制修饰符（如 private、protected、default、public），防止外部直接修改对象的内部数据。
控制访问方式：通过提供公共的方法（如 getter 和 setter），我们可以控制对对象属性的访问方式，甚至可以在设置或获取数据时进行验证或其他处理。
提高代码的可维护性：由于数据的访问和修改都通过方法进行，代码的变化不会影响外部对该对象的使用。

示例：

public class Person {
    private String name; // 私有属性，无法直接访问
    private int age;

    // 公共方法来访问和修改私有属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) { // 在设置值时进行验证
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }
}

在上面的代码中，name 和 age 是私有的，外部无法直接访问和修改它们。通过 getName、setName、getAge 和 setAge 方法，外部可以通过这些接口来访问和修改这些属性。

2. 继承（Inheritance）

继承是面向对象的核心特性之一，它允许一个类继承另一个类的属性和方法。继承使得代码可以复用，从而减少重复代码，提高系统的可维护性。

继承的好处：

代码复用：子类继承父类的字段和方法，避免了重复编写相同的代码。
易于扩展：通过继承，子类可以继承父类的功能，并可以根据需要进行扩展和修改。
层次化关系：继承定义了类之间的层次结构，符合现实世界的“is-a”关系（例如，“狗是动物的一种”）。

示例：

// 父类（超类）
public class Animal {
    public void eat() {
        System.out.println("This animal eats food.");
    }
}

// 子类（派生类）
public class Dog extends Animal {
    // 子类可以重写父类的方法
    @Override
    public void eat() {
        System.out.println("This dog eats meat.");
    }

    public void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 调用 Dog 类中重写的 eat 方法
        dog.bark(); // 调用 Dog 类的独有方法
    }
}

在上面的代码中，Dog 类继承了 Animal 类，因此它可以直接使用 Animal 类的 eat() 方法。同时，Dog 类重写了 eat() 方法，提供了特定的实现。

super 关键字

3. 多态（Polymorphism）

多态是指同一个方法在不同的对象上可以表现出不同的行为。多态有两种主要形式：方法重载和方法重写。

方法重载（静态多态）：同一个类中，可以定义多个方法，它们具有相同的名称，但参数不同。
方法重写（动态多态）：子类重写父类的方法，父类引用指向子类对象时，调用的是子类重写后的方法。

多态的好处：

提高灵活性：通过使用父类类型的引用，可以实现对不同子类对象的操作，而不需要在编译时知道具体的子类类型。
增强可扩展性：可以通过增加新的子类而不修改已有代码来扩展系统的功能。

示例：

// 父类
public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类
public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

// 另一个子类
public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.sound(); // 输出 "Animal makes a sound"
        myDog.sound(); // 输出 "Dog barks"
        myCat.sound(); // 输出 "Cat meows"
    }
}

在上面的代码中，Dog 和 Cat 都继承自 Animal 类，并重写了 sound() 方法。尽管 myDog 和 myCat 都是 Animal 类型的引用，但是它们调用的 sound() 方法是根据实际的对象类型（即 Dog 或 Cat）来确定的。这就是动态多态的体现。

拓展：编译时多态和运行时多态